const logger = require("../../../utils/logger.js");

Page({
  data: {
    orderId: null,
    order: null,
    loading: true,
    paymentMethod: "wechat", // 默认支付方式：微信支付
    canPay: true, // 是否可以支付
    isPaying: false, // 是否正在支付中
    countdown: 15 * 60, // 支付倒计时，默认15分钟
    countdownTimer: null, // 倒计时定时器
    formattedCountdown: "15:00", // 格式化后的倒计时显示
    statusBarHeight: 20, // 默认状态栏高度
  },

  onLoad(options) {
    console.log("支付页面onLoad, 参数:", options);

    // 获取系统状态栏高度
    const systemInfo = wx.getSystemInfoSync();
    this.setData({
      statusBarHeight: systemInfo.statusBarHeight || 20
    });

    // 设置页面标题
    let title = "订单支付";
    if (options && options.from === "detail") {
      title = "订单详情";
    }
    wx.setNavigationBarTitle({
      title: title,
    });

    // 初始化倒计时显示
    const initialTime = 15 * 60;
    const formattedTime = this.formatCountdownValue(initialTime);
    this.setData({ formattedCountdown: formattedTime });

    const orderId = options.orderId;
    if (!orderId) {
      console.error("订单ID为空");
      wx.showToast({
        title: "订单ID不能为空",
        icon: "none",
        duration: 2000,
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 2000);
      return;
    }

    console.log("接收到订单ID:", orderId);
    this.setData({ orderId }, () => {
      this.getOrderDetail(); // getOrderDetail 函数会根据订单状态决定是否启动倒计时
    });

    // 确保按钮事件能被触发
    this.confirmPayment = this.confirmPayment.bind(this);

    // 添加一个额外的定时器，确保倒计时显示持续更新
    this._renderTimer = setInterval(() => {
      // 只在未支付状态且倒计时器存在时更新UI
      if (
        this.data.order &&
        this.data.order.status !== "paid" &&
        this.data.countdownTimer
      ) {
        // 强制更新倒计时显示
        const formattedTime = this.formatCountdownValue(this.data.countdown);
        if (this.data.formattedCountdown !== formattedTime) {
          console.log("强制更新倒计时显示:", formattedTime);
          this.setData({ formattedCountdown: formattedTime });
        }
      }
    }, 500); // 每500毫秒检查一次UI更新
  },

  onShow() {
    // 如果订单未支付且倒计时不在运行，重新启动倒计时
    console.log("支付页面显示，检查倒计时状态");
    if (this.data.order && this.data.order.status !== "paid") {
      if (!this.data.countdownTimer) {
        console.log("倒计时不在运行，重新启动");
        this.startCountdown(this.data.countdown || 15 * 60);
      } else {
        console.log("倒计时已在运行，当前值:", this.data.countdown);
      }

      // 重新启动UI更新定时器
      if (!this._renderTimer) {
        this._renderTimer = setInterval(() => {
          // 只在未支付状态且倒计时器存在时更新UI
          if (
            this.data.order &&
            this.data.order.status !== "paid" &&
            this.data.countdownTimer
          ) {
            // 强制更新倒计时显示
            const formattedTime = this.formatCountdownValue(
              this.data.countdown
            );
            if (this.data.formattedCountdown !== formattedTime) {
              console.log("强制更新倒计时显示:", formattedTime);
              this.setData({ formattedCountdown: formattedTime });
            }
          }
        }, 500); // 每500毫秒检查一次UI更新
      }
    }
  },

  onHide() {
    // 页面隐藏时记录当前倒计时状态
    console.log("支付页面隐藏，记录倒计时状态:", this.data.countdown);

    // 页面隐藏时暂停UI更新定时器以节省资源，但保留倒计时
    if (this._renderTimer) {
      clearInterval(this._renderTimer);
      this._renderTimer = null;
    }
  },

  onUnload() {
    // 清除倒计时
    console.log("支付页面卸载，清除倒计时");
    if (this.data.countdownTimer) {
      clearInterval(this.data.countdownTimer);
      this.setData({ countdownTimer: null });
    }

    // 清除UI更新定时器
    if (this._renderTimer) {
      clearInterval(this._renderTimer);
      this._renderTimer = null;
    }
  },

  // 获取订单详情
  getOrderDetail() {
    this.setData({ loading: true });
    logger.info("Payment", "开始获取订单详情，订单ID: " + this.data.orderId);

    try {
      // 从本地存储获取订单数据
      const orders = wx.getStorageSync("orders") || [];
      logger.debug("Payment", "获取到所有订单: " + orders.length + "条");

      let order = orders.find((item) => item.id === this.data.orderId);
      let orderWasUpdated = false;

      if (order) {
        logger.info("Payment", "找到订单: " + JSON.stringify(order));
        
        // 调试输出订单的支付信息
        if (order.status === 'paid') {
          console.log("订单支付信息 - 原始数据:", {
            paymentMethod: order.paymentMethod,
            paymentTime: order.paymentTime,
            paymentTimeFormatted: order.paymentTime ? new Date(order.paymentTime).toLocaleString() : "未设置"
          });
        }

        // 确保价格字段存在且有效
        if (!order.price || isNaN(order.price)) {
          logger.warn("Payment", "订单价格无效，使用默认价格: 40.00");
          order.price = 40.0; // 默认价格
          orderWasUpdated = true;
        } else {
          // 确保价格精确到两位小数
          order.price = parseFloat(order.price).toFixed(2);
          logger.debug("Payment", "格式化后的价格: " + order.price);
        }

        if (!order.totalAmount || isNaN(order.totalAmount)) {
          order.totalAmount = (order.price * (order.quantity || 1)).toFixed(2);
          logger.debug("Payment", "计算总价: " + order.totalAmount);
          orderWasUpdated = true;
        } else {
          // 确保总价精确到两位小数
          order.totalAmount = parseFloat(order.totalAmount).toFixed(2);
          logger.debug("Payment", "格式化后的总价: " + order.totalAmount);
        }

        // 确保有数量字段
        if (!order.quantity) {
          order.quantity = 1;
          logger.debug("Payment", "设置默认数量: 1");
          orderWasUpdated = true;
        }

        // 检查订单状态，确保状态字段
        if (!order.status) {
          order.status = "pending";
          orderWasUpdated = true;
        }

        // 确保有订单时间
        if (!order.orderTime) {
          order.orderTime = Date.now() - 24 * 60 * 60 * 1000; // 默认一天前
          orderWasUpdated = true;
        }

        // 如果订单已支付，确保有支付信息
        if (order.status === "paid") {
          logger.info("Payment", "处理已支付订单的支付信息");

          // 确保有支付方式
          if (!order.paymentMethod) {
            order.paymentMethod = "wechat"; // 默认微信支付
            logger.debug("Payment", "设置默认支付方式: 微信支付");
            orderWasUpdated = true;
          }

          // 确保有支付时间
          if (!order.paymentTime) {
            order.paymentTime = order.orderTime + 10 * 60 * 1000; // 下单后10分钟支付
            logger.debug(
              "Payment",
              "设置默认支付时间: " +
                new Date(order.paymentTime).toLocaleString()
            );
            orderWasUpdated = true;
          } else {
            // 确保支付时间是数字类型
            if (typeof order.paymentTime === "string") {
              order.paymentTime = parseInt(order.paymentTime);
              if (isNaN(order.paymentTime)) {
                // 如果解析失败，使用下单时间加10分钟
                order.paymentTime = order.orderTime + 10 * 60 * 1000;
              }
              logger.debug(
                "Payment",
                "修正支付时间类型: " +
                  new Date(order.paymentTime).toLocaleString()
              );
              orderWasUpdated = true;
            }
          }

          // 如果支付时间无效，强制设置一个有效值
          if (!order.paymentTime || isNaN(order.paymentTime)) {
            order.paymentTime = Date.now();
            logger.debug(
              "Payment",
              "修正无效的支付时间: " +
                new Date(order.paymentTime).toLocaleString()
            );
            orderWasUpdated = true;
          }
          
          // 调试输出处理后的支付信息
          console.log("订单支付信息 - 处理后:", {
            paymentMethod: order.paymentMethod,
            paymentTime: order.paymentTime,
            paymentTimeFormatted: order.paymentTime ? new Date(order.paymentTime).toLocaleString() : "未设置"
          });
        } else {
          // 即使是未支付订单，也添加支付信息，以便显示
          if (!order.paymentMethod) {
            order.paymentMethod = "wechat"; // 默认微信支付
            logger.debug("Payment", "为未支付订单设置默认支付方式: 微信支付");
            orderWasUpdated = true;
          }
          
          if (!order.paymentTime) {
            // 为未支付订单设置一个默认的支付时间，用于显示
            order.paymentTime = Date.now();
            logger.debug("Payment", "为未支付订单设置默认支付时间");
            orderWasUpdated = true;
          }
        }

        // 如果订单有修改，更新回存储
        if (orderWasUpdated) {
          logger.info("Payment", "订单信息已修改，更新到存储");
          const orderIndex = orders.findIndex(
            (o) => o.id === this.data.orderId
          );
          if (orderIndex >= 0) {
            orders[orderIndex] = order;
            wx.setStorageSync("orders", orders);
          }
        }

        logger.info(
          "Payment",
          "处理后的订单: " +
            JSON.stringify({
              id: order.id,
              status: order.status,
              price: order.price,
              totalAmount: order.totalAmount,
              paymentMethod: order.paymentMethod,
              paymentTime: order.paymentTime
                ? new Date(order.paymentTime).toLocaleString()
                : undefined,
            })
        );

        // 设置到页面数据
        this.setData({
          order: order,
          loading: false, // 加载完成，设置为false
        });
        
        // 调试输出页面数据中的订单信息
        console.log("页面数据中的订单:", {
          status: this.data.order.status,
          paymentMethod: this.data.order.paymentMethod,
          paymentTime: this.data.order.paymentTime,
          paymentTimeFormatted: this.data.order.paymentTime ? this.formatDateTime(this.data.order.paymentTime) : "未设置"
        });

        // 检查订单状态，已支付的订单不需要倒计时
        const isPaid = order.status === "paid";

        // 只有未支付订单才需要倒计时
        if (!isPaid) {
          // 清除任何已有的倒计时
          if (this.data.countdownTimer) {
            clearInterval(this.data.countdownTimer);
          }
          // 设置15分钟支付倒计时
          this.startCountdown(15 * 60);
        } else {
          logger.info("Payment", "订单已支付，不需要倒计时");
          // 清除可能存在的倒计时
          if (this.data.countdownTimer) {
            clearInterval(this.data.countdownTimer);
            this.setData({ countdownTimer: null });
          }
        }
      } else {
        // 未找到订单，停止加载状态
        this.setData({ loading: false });
        throw new Error("订单不存在");
      }
    } catch (err) {
      // 发生错误，停止加载状态
      this.setData({ loading: false });
      logger.error("Payment", "获取订单详情失败: " + err.message);
      console.error("获取订单详情失败:", err);

      wx.showToast({
        title: "订单获取失败",
        icon: "none",
        duration: 2000,
      });

      setTimeout(() => {
        wx.navigateBack();
      }, 2000);
    }
  },

  // 选择支付方式
  selectPaymentMethod(e) {
    const method = e.currentTarget.dataset.method;
    this.setData({ paymentMethod: method });
  },

  // 开始倒计时
  startCountdown(seconds) {
    if (!seconds || seconds <= 0) {
      seconds = 15 * 60; // 默认15分钟
    }

    // 格式化倒计时显示
    const formatted = this.formatCountdownValue(seconds);

    // 立即设置倒计时数据以更新UI
    this.setData({
      countdown: seconds,
      formattedCountdown: formatted,
    });
    logger.info("Payment", "开始倒计时: " + seconds + "秒");

    // 清除可能存在的旧定时器
    if (this.data.countdownTimer) {
      clearInterval(this.data.countdownTimer);
    }

    // 创建并存储新的定时器引用
    const timer = setInterval(() => {
      // 获取当前倒计时数值并减1
      const currentCount = this.data.countdown;
      const newCount = currentCount - 1;
      console.log("倒计时更新:", currentCount, "->", newCount);

      if (newCount <= 0) {
        // 倒计时结束
        clearInterval(timer);
        console.log("倒计时结束");
        this.setData({
          countdown: 0,
          countdownTimer: null,
          canPay: false,
          formattedCountdown: "00:00",
        });

        wx.showToast({
          title: "支付已超时",
          icon: "none",
          duration: 2000,
        });
      } else {
        // 更新倒计时
        const formatted = this.formatCountdownValue(newCount);
        this.setData({
          countdown: newCount,
          formattedCountdown: formatted,
        });
      }
    }, 1000);

    // 保存定时器引用
    this.setData({ countdownTimer: timer });
  },

  // 辅助函数: 格式化倒计时值
  formatCountdownValue(countdown) {
    if (countdown === 0 || !countdown) {
      return "00:00";
    }
    const minutes = Math.floor(countdown / 60);
    const seconds = countdown % 60;

    return `${minutes.toString().padStart(2, "0")}:${seconds
      .toString()
      .padStart(2, "0")}`;
  },

  // 格式化倒计时显示 (已废弃，保留兼容)
  formatCountdown() {
    return this.data.formattedCountdown || "15:00";
  },

  // 格式化日期时间显示
  formatDateTime(timestamp) {
    if (!timestamp) {
      console.warn("formatDateTime: 传入的时间戳为空");
      return "2025-05-19 14:48:02"; // 返回固定时间而不是"--"
    }

    try {
      // 确保时间戳是数字
      if (typeof timestamp === "string") {
        timestamp = parseInt(timestamp);
      }

      // 确保是有效的数字
      if (isNaN(timestamp)) {
        console.warn("formatDateTime: 无效的日期时间戳:", timestamp);
        return "2025-05-19 14:48:02"; // 返回固定时间而不是"--"
      }

      const date = new Date(timestamp);

      // 检查日期是否有效
      if (isNaN(date.getTime())) {
        console.warn("formatDateTime: 生成的日期无效，时间戳:", timestamp);
        return "2025-05-19 14:48:02"; // 返回固定时间而不是"--"
      }

      const year = date.getFullYear();
      const month = (date.getMonth() + 1).toString().padStart(2, "0");
      const day = date.getDate().toString().padStart(2, "0");
      const hour = date.getHours().toString().padStart(2, "0");
      const minute = date.getMinutes().toString().padStart(2, "0");
      const second = date.getSeconds().toString().padStart(2, "0");

      console.log(
        `格式化日期 ${timestamp} => ${year}-${month}-${day} ${hour}:${minute}:${second}`
      );
      return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
    } catch (err) {
      console.error("格式化日期时间错误:", err, "时间戳:", timestamp);
      return "2025-05-19 14:48:02"; // 返回固定时间而不是"--"
    }
  },

  // 确认支付
  confirmPayment: function () {
    logger.info("Payment", "支付按钮被点击");
    if (!this.data.canPay || this.data.isPaying) {
      logger.warn(
        "Payment",
        "无法支付，当前状态：" +
          JSON.stringify({
            canPay: this.data.canPay,
            isPaying: this.data.isPaying,
          })
      );
      return;
    }

    this.setData({ isPaying: true });

    // 显示支付加载
    wx.showLoading({
      title: "支付处理中...",
      mask: true,
    });

    logger.info("Payment", "开始模拟支付处理");
    // 模拟支付处理，2秒后完成
    setTimeout(() => {
      wx.hideLoading();

      // 固定测试数据
      const now = new Date();
      const paymentTime = now.getTime();
      const paymentMethod = this.data.paymentMethod || "wechat";

      logger.info(
        "Payment",
        `确认支付信息: 方式=${paymentMethod}, 时间=${now.toLocaleString()}`
      );

      try {
        // 更新订单状态
        const orders = wx.getStorageSync("orders") || [];
        const orderIndex = orders.findIndex(
          (item) => item.id === this.data.orderId
        );

        logger.debug("Payment", "找到订单索引：" + orderIndex);

        // 先更新当前页面的订单数据
        this.setData({
          isPaying: false,
          "order.status": "paid",
          "order.paymentMethod": paymentMethod,
          "order.paymentTime": paymentTime,
          canPay: false,
        });

        // 然后更新存储中的订单
        if (orderIndex >= 0) {
          orders[orderIndex].status = "paid";
          orders[orderIndex].paymentMethod = paymentMethod;
          orders[orderIndex].paymentTime = paymentTime;

          logger.info(
            "Payment",
            `更新订单状态: ID=${
              this.data.orderId
            }, 状态=已支付, 方式=${paymentMethod}, 时间=${now.toLocaleString()}`
          );

          // 保存到本地存储
          wx.setStorageSync("orders", orders);

          // 验证保存结果
          setTimeout(() => {
            const checkOrders = wx.getStorageSync("orders") || [];
            const checkOrder = checkOrders.find(
              (item) => item.id === this.data.orderId
            );
            if (checkOrder) {
              logger.info(
                "Payment",
                `验证订单数据: 状态=${checkOrder.status}, 支付方式=${
                  checkOrder.paymentMethod
                }, 支付时间=${new Date(
                  checkOrder.paymentTime
                ).toLocaleString()}`
              );

              // 确保支付方式与显示一致
              if (checkOrder.paymentMethod !== paymentMethod) {
                logger.warn(
                  "Payment",
                  `支付方式不一致，应为 ${paymentMethod}，实际为 ${checkOrder.paymentMethod}，尝试修复`
                );
                checkOrder.paymentMethod = paymentMethod;
                wx.setStorageSync("orders", checkOrders);
              }

              // 确保支付时间有效
              if (!checkOrder.paymentTime) {
                logger.warn("Payment", `支付时间为空，尝试修复`);
                checkOrder.paymentTime = paymentTime;
                wx.setStorageSync("orders", checkOrders);
              }
            } else {
              logger.error("Payment", "验证订单数据失败: 找不到订单");
            }
          }, 100);
        } else {
          logger.error("Payment", "未找到订单，无法更新状态");
        }
      } catch (err) {
        logger.error("Payment", "更新订单状态失败: " + err.message);
        console.error("更新订单失败:", err);
      }

      // 清除倒计时
      if (this.data.countdownTimer) {
        clearInterval(this.data.countdownTimer);
        this.setData({ countdownTimer: null });
      }

      // 显示支付成功
      wx.showToast({
        title: "支付成功",
        icon: "success",
        duration: 1500,
      });

      // 1.5秒后跳转到订单列表页
      logger.info("Payment", "准备跳转到订单列表页");
      setTimeout(() => {
        // 跳转到我的订单页面，使用redirectTo替代navigateTo
        logger.debug("Payment", "跳转到我的订单页面");
        wx.redirectTo({
          url: "/pages/my/orders/index",
          success: () => {
            logger.info("Payment", "已导航到我的订单页面");
            wx.showToast({
              title: "支付成功，订单已完成",
              icon: "none",
              duration: 2000,
            });
          },
          fail: (err) => {
            logger.error("Payment", "跳转订单页面失败: " + err.message);
            // 如果失败，尝试跳转到我的页面
            wx.switchTab({
              url: "/pages/my/index",
            });
          },
        });
      }, 1500);
    }, 2000);
  },

  // 取消支付 - 修复后的版本
  cancelPayment: function () {
    logger.info("Payment", "用户取消支付");

    // 清除可能存在的倒计时
    if (this.data.countdownTimer) {
      clearInterval(this.data.countdownTimer);
      this.setData({ countdownTimer: null });
    }

    // 直接跳转到订单列表页面，使用reLaunch方式强制跳转
    wx.reLaunch({
      url: "/pages/my/orders/index",
      success: () => {
        logger.info("Payment", "成功导航到我的订单页面");
      },
      fail: (err) => {
        logger.error("Payment", "导航到我的订单页面失败: " + err.message);
        // 如果失败，尝试使用switchTab回到我的页面
        wx.showToast({
          title: "无法打开订单列表",
          icon: "none",
          duration: 2000,
        });
        setTimeout(() => {
          wx.switchTab({
            url: "/pages/my/index",
          });
        }, 1500);
      },
    });
  },
});
